home *** CD-ROM | disk | FTP | other *** search
/ Inside Multimedia 1994 April / Inside Multimedia CD-ROM (April 1994).iso / prg / gs / gssource.exe / GDEVMSWN.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-24  |  28.6 KB  |  1,001 lines
  1. /* Copyright (C) 1989, 1992 Aladdin Enterprises.  All rights reserved.
  2.    Distributed by Free Software Foundation, Inc.
  3.  
  4. This file is part of Ghostscript.
  5.  
  6. Ghostscript is distributed in the hope that it will be useful, but
  7. WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility
  8. to anyone for the consequences of using it or for whether it serves any
  9. particular purpose or works at all, unless he says so in writing.  Refer
  10. to the Ghostscript General Public License for full details.
  11.  
  12. Everyone is granted permission to copy, modify and redistribute
  13. Ghostscript, but only under the conditions described in the Ghostscript
  14. General Public License.  A copy of this license is supposed to have been
  15. given to you along with Ghostscript so you can know your rights and
  16. responsibilities.  It should be in a file named COPYING.  Among other
  17. things, the copyright notice and this notice must be preserved on all
  18. copies.  */
  19.  
  20. /* gdevmswn.c */
  21. /*
  22.  * Microsoft Windows 3.n driver for Ghostscript.
  23.  * Original version by Russell Lang and Maurice Castro with help from
  24.  * Programming Windows, 2nd Ed., Charles Petzold, Microsoft Press;
  25.  * created from gdevbgi.c and gnuplot/term/win.trm 5th June 1992.
  26.  * Extensively modified by L. Peter Deutsch, Aladdin Enterprises.
  27.  */
  28. #include <windows.h>
  29. #include <string.h>
  30. #include <stdlib.h>
  31. #include "gx.h"
  32. #include "gserrors.h"
  33. #include "gxdevice.h"
  34. #include "gp.h"
  35. #include "gpcheck.h"
  36.  
  37. /* system menu constants for image window */
  38. #define M_COPY_CLIP 1
  39.  
  40. /* externals from gp_win.c */
  41. extern HWND FAR hwndeasy;
  42. extern HANDLE FAR phInstance;
  43. extern const char FAR szAppName[];
  44. extern gx_device *gdev_win_open_list;
  45.  
  46. typedef struct gx_device_win_s gx_device_win;
  47.  
  48. /* Forward references */
  49. private LPLOGPALETTE win_makepalette(P1(gx_device_win *));
  50. private void win_makeimg(P1(gx_device_win *));
  51. private void win_addtool(P2(gx_device_win *, int));
  52. private void win_maketools(P2(gx_device_win *, HDC));
  53. private void win_destroytools(P1(gx_device_win *));
  54. private void win_nomemory();
  55. private void win_update(P2(gx_device_win *, int));
  56. private const char FAR imgname[] = "Ghostscript Image";
  57.  
  58. /* See gxdevice.h for the definitions of the procedures. */
  59.  
  60. private dev_proc_open_device(win_open);
  61. private dev_proc_sync_output(win_sync_output);
  62. private dev_proc_output_page(win_output_page);
  63. private dev_proc_close_device(win_close);
  64. private dev_proc_map_rgb_color(win_map_rgb_color);
  65. private dev_proc_map_color_rgb(win_map_color_rgb);
  66. private dev_proc_fill_rectangle(win_fill_rectangle);
  67. private dev_proc_tile_rectangle(win_tile_rectangle);
  68. private dev_proc_copy_mono(win_copy_mono);
  69. private dev_proc_copy_color(win_copy_color);
  70. private dev_proc_draw_line(win_draw_line);
  71.  
  72. /* The device descriptor */
  73. struct gx_device_win_s {
  74.     gx_device_common;
  75.     int nColors;
  76.  
  77.     /* Handles */
  78.  
  79.     HWND FAR hwndimg;
  80.     HBITMAP FAR hbitmap;
  81.     HDC FAR hdcbit;
  82.     HPEN hpen, *hpens;
  83.     HBRUSH hbrush, *hbrushs;
  84.     HPALETTE hpalette, himgpalette;
  85.     LPLOGPALETTE lpalette, limgpalette;
  86.  
  87.     /* A staging bitmap for copy_mono. */
  88.     /* We want one big enough to handle the standard 16x16 halftone; */
  89.     /* this is also big enough for ordinary-size characters. */
  90.  
  91. #define bmWidthBytes 4        /* must be even */
  92. #define bmWidthBits (bmWidthBytes * 8)
  93. #define bmHeight 16
  94.     HBITMAP FAR hbmmono;
  95.     HDC FAR hdcmono;
  96. #define rop_write_at_1s 0xE20746L    /* write brush at 1's */
  97. #define rop_write_at_0s 0xB8074AL    /* write brush at 0's */
  98.     gx_bitmap_id bm_id;
  99.  
  100.     /* Window scrolling stuff */
  101.  
  102.     int cxClient, cyClient;
  103.     int cxAdjust, cyAdjust;
  104.     int nVscrollPos, nVscrollMax;
  105.     int nHscrollPos, nHscrollMax;
  106.  
  107.     /* Link for the list of open Windows devices */
  108.  
  109.     gx_device_win *next_wdev;
  110. };
  111. #define wdev ((gx_device_win *)dev)
  112. static gx_device_procs win_procs = {
  113.     win_open,
  114.     gx_default_get_initial_matrix,
  115.     win_sync_output,
  116.     win_output_page,
  117.     win_close,
  118.     win_map_rgb_color,
  119.     win_map_color_rgb,
  120.     win_fill_rectangle,
  121.     win_tile_rectangle,
  122.     win_copy_mono,
  123.     win_copy_color,
  124.     win_draw_line,
  125.     gx_default_get_bits,
  126.     gx_default_get_props,
  127.     gx_default_put_props
  128. };
  129. gx_device_win gs_mswin_device = {
  130.     sizeof(gx_device_win),
  131.     &win_procs,
  132.     "win",
  133.     32767, 32767,     /* win_open() fills these in later */
  134.     96.0, 96.0,    /* win_open() fills these in later */
  135.     no_margins,
  136.     dci_black_and_white,
  137.     0,        /* not open yet */
  138.     2        /* nColors = 2 */
  139. };
  140.  
  141. /* Open the win driver */
  142. private int
  143. win_open(gx_device *dev)
  144. {    HDC hdc;
  145.     int i;
  146.  
  147.     win_makeimg(wdev);
  148.     ShowWindow(wdev->hwndimg, SW_SHOWMINIMIZED);
  149.     BringWindowToTop(hwndeasy);
  150.  
  151.     hdc = GetDC(wdev->hwndimg);
  152.  
  153.     /* Set parameters that were unknown before opening device */
  154.     if (dev->width == 32767)
  155.       dev->width  = (int)(8.23 * dev->x_pixels_per_inch);
  156.     if (dev->height == 32767)
  157.       dev->height = (int)(11.7 * dev->y_pixels_per_inch);
  158.  
  159.     dev->width *= 1.3;
  160.     dev->height *= 1.3;
  161.     dev->x_pixels_per_inch *= 1.3;
  162.     dev->y_pixels_per_inch *= 1.3;
  163.     /* Find out if the device supports color */
  164.     /* We recognize 2, 16 or 256 color devices */
  165.     wdev->nColors = 1 << (GetDeviceCaps(hdc,PLANES) * GetDeviceCaps(hdc,BITSPIXEL));
  166.     if ( wdev->nColors >= 256 ) { /* use 64 static colors and 166 dynamic colors from 8 planes */
  167.         static const gx_device_color_info win_256color = dci_color(8,31,4);
  168.         dev->color_info = win_256color;
  169.         wdev->nColors = 64;
  170.     }
  171.     else if ( wdev->nColors >= 16 ) {
  172.         static const gx_device_color_info win_16color = dci_color(4, 2, 3);
  173.         dev->color_info = win_16color;
  174.         wdev->nColors = 16;
  175.     } 
  176.     else {   /* default is black_and_white */
  177.         wdev->nColors = 2;
  178.     }
  179.     
  180.     wdev->hbitmap = CreateCompatibleBitmap(hdc,dev->width,dev->height);
  181.     for (i=0; (wdev->hbitmap==(HBITMAP)NULL) && (i<4); i++) {
  182.         fprintf(stderr,"\nNot enough memory for bitmap.  Halving resolution... ");
  183.         dev->x_pixels_per_inch = dev->x_pixels_per_inch/2;
  184.         dev->y_pixels_per_inch = dev->y_pixels_per_inch/2;
  185.         dev->width  = dev->width/2;
  186.         dev->height = dev->height/2;
  187.         wdev->hbitmap = CreateCompatibleBitmap(hdc,dev->width,dev->height);
  188.     }
  189.     if (wdev->hbitmap==(HBITMAP)NULL) {
  190.         ReleaseDC(wdev->hwndimg, hdc);
  191.         win_nomemory();
  192.     }
  193.  
  194.     /* Create the bitmap and DC for copy_mono. */
  195.     wdev->hbmmono = CreateBitmap(bmWidthBits, bmHeight, 1, 1, NULL);
  196.     wdev->hdcmono = CreateCompatibleDC(hdc);
  197.     if ( wdev->hbmmono == NULL || wdev->hdcmono == NULL )
  198.     {    DeleteObject(wdev->hbitmap);
  199.         ReleaseDC(wdev->hwndimg, hdc);
  200.         win_nomemory();
  201.     }
  202.     SetMapMode(wdev->hdcmono, GetMapMode(hdc));
  203.     SelectObject(wdev->hdcmono, wdev->hbmmono);
  204.     wdev->bm_id = gx_no_bitmap_id;
  205.        
  206.     wdev->hdcbit = CreateCompatibleDC(hdc);  /* create Device Context for drawing */
  207.     SelectObject(wdev->hdcbit,wdev->hbitmap);
  208.     ReleaseDC(wdev->hwndimg, hdc);
  209.  
  210.     /* create palette and tools for bitmap */
  211.     if ((wdev->lpalette = win_makepalette(wdev))
  212.         == (LPLOGPALETTE)NULL)
  213.         win_nomemory();
  214.     wdev->hpalette = CreatePalette(wdev->lpalette);
  215.     (void) SelectPalette(wdev->hdcbit,wdev->hpalette,NULL);
  216.     RealizePalette(wdev->hdcbit);
  217.     win_maketools(wdev,wdev->hdcbit);
  218.  
  219.     /* create palette for display */
  220.     if ((wdev->limgpalette = win_makepalette(wdev))
  221.         == (LPLOGPALETTE)NULL)
  222.         win_nomemory();
  223.     wdev->himgpalette = CreatePalette(wdev->limgpalette);
  224.  
  225.     /* Initialize the scrolling information. */
  226.     
  227.     wdev->cxClient = wdev->cyClient = 0;
  228.     wdev->nVscrollPos = wdev->nVscrollMax = 0;
  229.     wdev->nHscrollPos = wdev->nHscrollMax = 0;
  230.  
  231.     /* Link this device onto the list */
  232.     wdev->next_wdev = (gx_device_win *)gdev_win_open_list;
  233.     gdev_win_open_list = dev;    
  234.  
  235.     return 0;
  236. }
  237.  
  238. /* Make the output appear on the screen. */
  239. private int
  240. win_sync_output(gx_device *dev)
  241. {
  242.     RECT rect;
  243.     if ( !IsWindow(wdev->hwndimg) ) {  /* some clod closed the window */
  244.         win_makeimg(wdev);
  245.         ShowWindow(wdev->hwndimg, SW_SHOWMINIMIZED);
  246.     }
  247.     if ( !IsIconic(wdev->hwndimg) ) {  /* redraw window */
  248.         GetClientRect(wdev->hwndimg, &rect);
  249.         InvalidateRect(wdev->hwndimg, (LPRECT) &rect, 1);
  250.         UpdateWindow(wdev->hwndimg);
  251.     }
  252.     return(0);
  253. }
  254.  
  255. /* Make the window visible, and display the output. */
  256. private int
  257. win_output_page(gx_device *dev, int copies, int flush)
  258. {
  259.     if (IsIconic(wdev->hwndimg))    /* useless as an Icon so fix it */
  260.         ShowWindow(wdev->hwndimg, SW_SHOWNORMAL);
  261.  
  262.     BringWindowToTop(wdev->hwndimg);
  263.     return( win_sync_output(dev) );
  264. }
  265.  
  266. /* Close the win driver */
  267. private int
  268. win_close(gx_device *dev)
  269. {
  270.     /* Free resources */
  271.  
  272.     win_destroytools(wdev);
  273.     DeleteDC(wdev->hdcbit);
  274.     DeleteDC(wdev->hdcmono);
  275.     DeleteObject(wdev->hbitmap);
  276.     DeleteObject(wdev->hpalette);
  277.     DeleteObject(wdev->himgpalette);
  278.     DeleteObject(wdev->hbmmono);
  279.     free(wdev->lpalette);
  280.     free(wdev->limgpalette);
  281.     DestroyWindow(wdev->hwndimg);
  282.     gp_check_interrupts();    /* process WIN_DESTROY message */
  283.  
  284.     /* Unlink from list. We do this last so that the WndProc */
  285.     /* can process the destroy message. */
  286.  
  287.     {    gx_device_win **pwd = (gx_device_win **)&gdev_win_open_list;
  288.         while ( *pwd != 0 && *pwd != wdev )
  289.             pwd = &(*pwd)->next_wdev;
  290.         if ( pwd != 0 )        /* == 0 should never happen! */
  291.             *pwd = (*pwd)->next_wdev;
  292.     }
  293.  
  294.     return(0);
  295. }
  296.  
  297. /* Map a r-g-b color to the colors available under Windows */
  298. #define win_map32(z)\
  299.   ((((z) >> (gx_color_value_bits - 5)) << 3) +\
  300.    ((z) >> (gx_color_value_bits - 3)))
  301. private gx_color_index
  302. win_map_rgb_color(gx_device *dev, gx_color_value r, gx_color_value g,
  303.   gx_color_value b)
  304. {
  305.     switch(dev->color_info.depth) {
  306.       case 8: {
  307.         int i;
  308.         LPLOGPALETTE lpal = wdev->lpalette;
  309.         PALETTEENTRY *pep;
  310.         byte cr, cg, cb;
  311.  
  312.         /* map colors to 0->255 in 32 steps */
  313.         cr = win_map32(r);
  314.         cg = win_map32(g);
  315.         cb = win_map32(b);
  316.  
  317.         /* search in palette */
  318.         for ( i = 0, pep = &lpal->palPalEntry[i];
  319.               i < wdev->nColors; i++, pep++
  320.             )
  321.         {    if ((cr == pep->peRed) &&
  322.                 (cg == pep->peGreen) &&
  323.                 (cb == pep->peBlue))
  324.                 return((gx_color_index)i);    /* found it */
  325.         }
  326.         
  327.         /* next try adding it to palette */
  328.         if (i < 220) { /* allow 36 for windows and other apps */
  329.             LPLOGPALETTE lipal = wdev->limgpalette;
  330.             wdev->nColors = i+1;
  331.             DeleteObject(wdev->hpalette);
  332.               lpal->palPalEntry[i].peFlags = NULL;
  333.             lpal->palPalEntry[i].peRed   =  cr;
  334.             lpal->palPalEntry[i].peGreen =  cg;
  335.             lpal->palPalEntry[i].peBlue  =  cb;
  336.             lpal->palNumEntries = wdev->nColors;
  337.             wdev->hpalette = CreatePalette(lpal);
  338.             (void) SelectPalette(wdev->hdcbit,wdev->hpalette,NULL);
  339.             RealizePalette(wdev->hdcbit);
  340.             win_addtool(wdev, i);
  341.  
  342.             DeleteObject(wdev->himgpalette);
  343.              lipal->palPalEntry[i].peFlags = NULL;
  344.             lipal->palPalEntry[i].peRed   =  cr;
  345.             lipal->palPalEntry[i].peGreen =  cg;
  346.             lipal->palPalEntry[i].peBlue  =  cb;
  347.             lipal->palNumEntries = wdev->nColors;
  348.             wdev->himgpalette = CreatePalette(lipal);
  349.  
  350.             return((gx_color_index)i);    /* return new palette index */
  351.         }
  352.  
  353.         return(-1);    /* not found - dither instead */
  354.         }
  355.       case 4: {
  356.         int color =  ((r > gx_max_color_value / 4 ? 4 : 0) +
  357.              (g > gx_max_color_value / 4 ? 2 : 0) +
  358.              (b > gx_max_color_value / 4 ? 1 : 0) +
  359.               (r > gx_max_color_value / 4 * 3 ||
  360.               g > gx_max_color_value / 4 * 3 ? 8 : 0));
  361.         return((gx_color_index)color);
  362.         }
  363.     }
  364.     return (gx_default_map_rgb_color(dev,r,g,b));
  365. }
  366.  
  367. /* Map a color code to r-g-b. */
  368. private int
  369. win_map_color_rgb(gx_device *dev, gx_color_index color,
  370.   gx_color_value prgb[3])
  371. {
  372. gx_color_value one;
  373.     switch(dev->color_info.depth) {
  374.       case 8:
  375.         one = (gx_color_value) (gx_max_color_value / 255);
  376.         prgb[0] = wdev->lpalette->palPalEntry[(int)color].peRed * one;
  377.         prgb[1] = wdev->lpalette->palPalEntry[(int)color].peGreen * one;
  378.         prgb[2] = wdev->lpalette->palPalEntry[(int)color].peBlue * one;
  379.         break;
  380.       case 4:
  381.         one = ((int)color & 8 ? gx_max_color_value : gx_max_color_value / 2);
  382.         prgb[0] = ((int)color & 4 ? one : 0);
  383.         prgb[1] = ((int)color & 2 ? one : 0);
  384.         prgb[2] = ((int)color & 1 ? one : 0);
  385.         break;
  386.       default:
  387.         prgb[0] = prgb[1] = prgb[2] = 
  388.             (int)color ? gx_max_color_value : 0;
  389.     }
  390.     return 0;
  391. }
  392.  
  393.  
  394. /* Macro for filling a rectangle with a color. */
  395. /* Note that it starts with a declaration. */
  396. #define fill_rect(x, y, w, h, color)\
  397. RECT rect;\
  398. rect.left = x, rect.top = y;\
  399. rect.right = x + w, rect.bottom = y + h;\
  400. FillRect(wdev->hdcbit, &rect, wdev->hbrushs[(int)color])
  401.  
  402.  
  403. /* Fill a rectangle. */
  404. private int
  405. win_fill_rectangle(gx_device *dev, int x, int y, int w, int h,
  406.   gx_color_index color)
  407. {
  408.     if ( w > 0 && h > 0 )
  409.     {    fill_rect(x, y, w, h, color);
  410.         win_update(wdev, h);
  411.     }
  412.     
  413.     return 0;
  414. }
  415.  
  416. /* Tile a rectangle.  If neither color is transparent, */
  417. /* pre-clear the rectangle to color0 and just tile with color1. */
  418. /* This is faster because of how win_copy_mono is implemented. */
  419. /* Note that this also does the right thing for colored tiles. */
  420. private int
  421. win_tile_rectangle(gx_device *dev, const gx_bitmap *tile,
  422.   int x, int y, int w, int h, gx_color_index czero, gx_color_index cone,
  423.   int px, int py)
  424. {    if ( w <= 0 || h <= 0 ) return 0;
  425.     if ( czero != gx_no_color_index && cone != gx_no_color_index )
  426.        {    fill_rect(x, y, w, h, czero);
  427.         czero = gx_no_color_index;
  428.        }
  429.     if ( tile->raster == bmWidthBytes && tile->size.y <= bmHeight &&
  430.          (px | py) == 0 && cone != gx_no_color_index
  431.        )
  432.     {    /* We can do this much more efficiently */
  433.         /* by using the internal algorithms of copy_mono */
  434.         /* and gx_default_tile_rectangle. */
  435.         int width = tile->size.x;
  436.         int height = tile->size.y;
  437.         int rwidth = tile->rep_width;
  438.         int irx = ((rwidth & (rwidth - 1)) == 0 ? /* power of 2 */
  439.             x & (rwidth - 1) :
  440.             x % rwidth);
  441.         int ry = y % tile->rep_height;
  442.         int icw = width - irx;
  443.         int ch = height - ry;
  444.         int ex = x + w, ey = y + h;
  445.         int fex = ex - width, fey = ey - height;
  446.         int cx, cy;
  447.  
  448.         if (wdev->hbrush != wdev->hbrushs[(int)cone])
  449.         {    wdev->hbrush = wdev->hbrushs[(int)cone];
  450.             SelectObject(wdev->hdcbit,wdev->hbrush);
  451.         }
  452.  
  453.         if ( tile->id != wdev->bm_id || tile->id == gx_no_bitmap_id )
  454.         {    wdev->bm_id = tile->id;
  455.             SetBitmapBits(wdev->hbmmono,
  456.                       (DWORD)(bmWidthBytes * tile->size.y),
  457.                       (BYTE *)tile->data);
  458.         }
  459.  
  460. #define copy_tile(srcx, srcy, tx, ty, tw, th)\
  461.   BitBlt(wdev->hdcbit, tx, ty, tw, th, wdev->hdcmono, srcx, srcy, rop_write_at_1s)
  462.  
  463.         if ( ch > h ) ch = h;
  464.         for ( cy = y; ; )
  465.            {    if ( w <= icw )
  466.                 copy_tile(irx, ry, x, cy, w, ch);
  467.             else
  468.             {    copy_tile(irx, ry, x, cy, icw, ch);
  469.                 cx = x + icw;
  470.                 while ( cx <= fex )
  471.                 {    copy_tile(0, ry, cx, cy, width, ch);
  472.                     cx += width;
  473.                 }
  474.                 if ( cx < ex )
  475.                 {    copy_tile(0, ry, cx, cy, ex - cx, ch);
  476.                 }
  477.             }
  478.             if ( (cy += ch) >= ey ) break;
  479.             ch = (cy > fey ? ey - cy : height);
  480.             ry = 0;
  481.            }
  482.  
  483.         win_update(wdev, h);
  484.         return 0;
  485.     }
  486.     return gx_default_tile_rectangle(dev, tile, x, y, w, h, czero, cone, px, py);
  487. }
  488.  
  489.  
  490. /* Draw a line */
  491. private int
  492. win_draw_line(gx_device *dev, int x0, int y0, int x1, int y1,
  493.   gx_color_index color)
  494. {
  495.     if (wdev->hpen != wdev->hpens[(int)color]) {
  496.         wdev->hpen = wdev->hpens[(int)color];
  497.         SelectObject(wdev->hdcbit,wdev->hpen);
  498.     }
  499.     MoveTo(wdev->hdcbit, x0, y0);
  500.     LineTo(wdev->hdcbit, x1, y1);
  501.     return 0;
  502. }
  503.  
  504. /* Copy a monochrome bitmap.  The colors are given explicitly. */
  505. /* Color = gx_no_color_index means transparent (no effect on the image). */
  506. private int
  507. win_copy_mono(gx_device *dev,
  508.   const byte *base, int sourcex, int raster, gx_bitmap_id id,
  509.   int x, int y, int w, int h,
  510.   gx_color_index zero, gx_color_index one)
  511. {    const byte *ptr_line;
  512.     int width_bytes, height;
  513.     DWORD rop = rop_write_at_1s;
  514.     int color;
  515.     BYTE aBit[bmWidthBytes * bmHeight];
  516.     BYTE *aptr = aBit;
  517.  
  518.     if ( sourcex & ~7 )
  519.     {    base += sourcex >> 3;
  520.         sourcex &= 7;
  521.     }
  522.  
  523.     /* Break up large transfers into smaller ones. */
  524.     while ( sourcex + w > bmWidthBits )
  525.     {    int code = win_copy_mono(dev, base, sourcex + w - bmWidthBits,
  526.                      raster, gx_no_bitmap_id,
  527.                      x + w - bmWidthBits, y,
  528.                      bmWidthBits, h, zero, one);
  529.         if ( code < 0 ) return code;
  530.         w -= bmWidthBits;
  531.     }
  532.     while ( h > bmHeight )
  533.     {    int code = win_copy_mono(dev, base + (h - bmHeight) * raster,
  534.                      sourcex, raster, gx_no_bitmap_id,
  535.                      x, y + h - bmHeight,
  536.                      w, bmHeight, zero, one);
  537.         if ( code < 0 ) return code;
  538.         h -= bmHeight;
  539.     }
  540.  
  541.     if ( w <= 0 || h <= 0 ) return 0;
  542.     width_bytes = (sourcex + w + 7) >> 3;
  543.     ptr_line = base;
  544.  
  545.     if ( zero == gx_no_color_index )
  546.        {    if ( one == gx_no_color_index ) return 0;
  547.         color = (int)one;
  548.        }
  549.     else
  550.        {    if ( one == gx_no_color_index )
  551.            {    color = (int)zero;
  552.             rop = rop_write_at_0s;
  553.            }
  554.         else
  555.            {    /* Pre-clear the rectangle to zero */
  556.             fill_rect(x, y, w, h, zero);
  557.             color = (int)one;
  558.            }
  559.        }
  560.  
  561.     if (wdev->hbrush != wdev->hbrushs[(int)color])
  562.     {    wdev->hbrush = wdev->hbrushs[(int)color];
  563.         SelectObject(wdev->hdcbit,wdev->hbrush);
  564.     }
  565.  
  566.     if ( id != wdev->bm_id || id == gx_no_bitmap_id )
  567.     {    wdev->bm_id = id;
  568.         if ( raster == bmWidthBytes )
  569.         {    /* We can do the whole thing in a single transfer! */
  570.             SetBitmapBits(wdev->hbmmono,
  571.                       (DWORD)(bmWidthBytes * h),
  572.                       (BYTE *)base);
  573.         }
  574.         else
  575.         {    for ( height = h; height--;
  576.                   ptr_line += raster, aptr += bmWidthBytes
  577.                 )
  578.             {    /* Pack the bits into the bitmap. */
  579.                 switch ( width_bytes )
  580.                 {
  581.                     default: memcpy(aptr, ptr_line, width_bytes); break;
  582.                     case 4: aptr[3] = ptr_line[3];
  583.                     case 3: aptr[2] = ptr_line[2];
  584.                     case 2: aptr[1] = ptr_line[1];
  585.                     case 1: aptr[0] = ptr_line[0];
  586.                 }
  587.             }
  588.             SetBitmapBits(wdev->hbmmono,
  589.                       (DWORD)(bmWidthBytes * h),
  590.                       &aBit[0]);
  591.         }
  592.     }
  593.  
  594.     BitBlt(wdev->hdcbit, x, y, w, h, wdev->hdcmono, sourcex, 0, rop);
  595.     win_update(wdev, h);    /* message handler */
  596.     return 0;
  597. }
  598.  
  599.  
  600. /* Copy a color pixel map.  This is just like a bitmap, except that */
  601. /* each pixel takes 8 or 4 bits instead of 1 when device driver has color. */
  602. private int
  603. win_copy_color(gx_device *dev,
  604.   const byte *base, int sourcex, int raster, gx_bitmap_id id,
  605.   int x, int y, int w, int h)
  606. {    if ( gx_device_has_color(dev) )
  607.     {
  608.     switch(dev->color_info.depth) {
  609.       case 8:
  610.         {    int xi, yi;
  611.         int skip = raster - w;
  612.         const byte *sptr = base + sourcex;
  613.           if ( w <= 0 ) return 0;
  614.           if ( x < 0 || x + w > dev->width )
  615.             return_error(gs_error_rangecheck);
  616.         for ( yi = y; yi - y < h; yi++ )
  617.            {
  618.             for ( xi = x; xi - x < w; xi++ )
  619.                {    int color =  *sptr++;
  620.                 SetPixel(wdev->hdcbit,xi,yi,PALETTEINDEX(color));
  621.                }
  622.             sptr += skip;
  623.            }
  624.         }
  625.         break;
  626.       case 4:
  627.        {    /* color device, four bits per pixel */
  628.         const byte *line = base + (sourcex >> 1);
  629.         int dest_y = y, end_x = x + w;
  630.  
  631.         if ( w <= 0 ) return 0;
  632.         while ( h-- )              /* for each line */
  633.            {    const byte *source = line;
  634.             register int dest_x = x;
  635.             if ( sourcex & 1 )    /* odd nibble first */
  636.                {    int color =  *source++ & 0xf;
  637.                 SetPixel(wdev->hdcbit,dest_x,dest_y,PALETTEINDEX(color));
  638.                 dest_x++;
  639.                }
  640.             /* Now do full bytes */
  641.             while ( dest_x < end_x )
  642.                {    int color = *source >> 4;
  643.                 SetPixel(wdev->hdcbit,dest_x,dest_y,PALETTEINDEX(color));
  644.                 dest_x++;
  645.                 if ( dest_x < end_x )
  646.                    {    color =  *source++ & 0xf;
  647.                     SetPixel(wdev->hdcbit,dest_x,dest_y,PALETTEINDEX(color));
  648.                     dest_x++;
  649.                    }
  650.                }
  651.             dest_y++;
  652.             line += raster;
  653.            }
  654.        }
  655.        break;
  656.     default:
  657.         return(-1); /* panic */
  658.     }
  659.     }
  660.     else 
  661.     /* monochrome device: one bit per pixel */
  662.        {    /* bitmap is the same as win_copy_mono: one bit per pixel */
  663.         win_copy_mono(dev, base, sourcex, raster, id, x, y, w, h,
  664.             (gx_color_index)0, 
  665.             (gx_color_index)(dev->color_info.depth==8 ? 63 : dev->color_info.max_gray));
  666.        }
  667.     win_update(wdev, h);    /* message handler */
  668.     return 0;
  669. }
  670.  
  671. /* ------ Internal routines ------ */
  672.  
  673. #undef wdev
  674.  
  675. /* make image window */
  676. private void 
  677. win_makeimg(gx_device_win *wdev)
  678. {    HMENU sysmenu;
  679.     wdev->hwndimg = CreateWindow(szAppName, (LPSTR)imgname,
  680.           WS_OVERLAPPEDWINDOW | WS_VSCROLL | WS_HSCROLL,
  681.           CW_USEDEFAULT, CW_USEDEFAULT, 
  682.           CW_USEDEFAULT, CW_USEDEFAULT, 
  683.           NULL, NULL, phInstance, (LPSTR)NULL);
  684.     /* modify the menu to have the new items we want */
  685.     sysmenu = GetSystemMenu(wdev->hwndimg,0);    /* get the sysmenu */
  686.     AppendMenu(sysmenu, MF_SEPARATOR, 0, NULL);
  687.     AppendMenu(sysmenu, MF_STRING, M_COPY_CLIP, "Copy to Clip&board");
  688. }
  689.  
  690.  
  691. /* out of memory error exit with message box */
  692. private void
  693. win_nomemory()
  694. {
  695.            MessageBox(hwndeasy,(LPSTR)"Not enough memory",(LPSTR) szAppName, MB_ICONSTOP);
  696.     gs_exit(1);
  697. }
  698.  
  699.  
  700. private LPLOGPALETTE
  701. win_makepalette(gx_device_win *wdev)
  702. {    int i, val;
  703.     LPLOGPALETTE logpalette;
  704.     logpalette = (LPLOGPALETTE) malloc( sizeof(LOGPALETTE) + 
  705.         (1<<(wdev->color_info.depth)) * sizeof(PALETTEENTRY) );
  706.     if (logpalette == (LPLOGPALETTE)NULL)
  707.         return(0);
  708.     logpalette->palVersion = 0x300;
  709.     logpalette->palNumEntries = wdev->nColors;
  710.     for (i=0; i<wdev->nColors; i++) {
  711.       logpalette->palPalEntry[i].peFlags = NULL;
  712.       switch (wdev->nColors) {
  713.         case 64:
  714.           /* colors are rrggbb */
  715.           logpalette->palPalEntry[i].peRed   =
  716.               win_map32(((i & 0x30)>>4)*(gx_max_color_value/3));
  717.           logpalette->palPalEntry[i].peGreen =
  718.               win_map32(((i & 0xC)>>2)*(gx_max_color_value/3));
  719.           logpalette->palPalEntry[i].peBlue  =
  720.               win_map32((i & 3)*(gx_max_color_value/3));
  721.           break;
  722.         case 16:
  723.           /* colors are irgb */
  724.           val = (i & 8 ? 255 : 255 / 2);
  725.           logpalette->palPalEntry[i].peRed   = i & 4 ? val : 0;
  726.           logpalette->palPalEntry[i].peGreen = i & 2 ? val : 0;
  727.           logpalette->palPalEntry[i].peBlue  = i & 1 ? val : 0;
  728.           break;
  729.         case 2:
  730.           logpalette->palPalEntry[i].peRed =
  731.             logpalette->palPalEntry[i].peGreen =
  732.             logpalette->palPalEntry[i].peBlue = (i ? 255 : 0);
  733.           break;
  734.       }
  735.     }
  736.     return(logpalette);
  737. }
  738.  
  739.  
  740. private void
  741. win_addtool(gx_device_win *wdev, int i)
  742. {
  743.     wdev->hpens[i] = CreatePen(PS_SOLID, 1, PALETTEINDEX(i));
  744.     wdev->hbrushs[i] = CreateSolidBrush(PALETTEINDEX(i));
  745. }
  746.  
  747.  
  748. private void
  749. win_maketools(gx_device_win *wdev, HDC hdc)
  750. {    int i;
  751.     wdev->hpens = malloc( (1<<(wdev->color_info.depth)) * sizeof(HPEN) );
  752.     wdev->hbrushs = malloc( (1<<(wdev->color_info.depth)) * sizeof(HBRUSH) );
  753.     if (wdev->hpens && wdev->hbrushs) {
  754.         for (i=0; i<wdev->nColors; i++)
  755.             win_addtool(wdev, i);
  756.  
  757.         wdev->hpen = wdev->hpens[0];
  758.         SelectObject(hdc,wdev->hpen);
  759.  
  760.         wdev->hbrush = wdev->hbrushs[0];
  761.         SelectObject(hdc,wdev->hbrush);
  762.     }
  763. }
  764.  
  765.  
  766. private void
  767. win_destroytools(gx_device_win *wdev)
  768. {    int i;
  769.     for (i=0; i<wdev->nColors; i++) {
  770.         DeleteObject(wdev->hpens[i]);
  771.         DeleteObject(wdev->hbrushs[i]);
  772.     }
  773.     free(wdev->hpens);
  774.     free(wdev->hbrushs);
  775. }
  776.  
  777.  
  778. private void
  779. win_update(gx_device_win *wdev, int amount)
  780. {    /* Update the image screen every 5 seconds, */
  781.     /* checking the time every N scan lines. */
  782.     static int fcount = 0;
  783.     static long time;
  784.     long date_time[2];
  785.     
  786.     if (fcount == 0)
  787.     {    gp_get_clock(date_time);
  788.         time = date_time[1];
  789.     }
  790.     if ((fcount += amount) > 200 || fcount < 0)
  791.     {    long deltatime;
  792.         gp_get_clock(date_time);
  793.         deltatime = date_time[1] - time;
  794.         if ( (deltatime > 5000L) || (deltatime < 0L) )
  795.         {    win_sync_output((gx_device *)wdev);    /* time to redraw */
  796.             time = date_time[1];
  797.         }
  798.         fcount = 1;
  799.     }
  800. }
  801.  
  802.  
  803. long far PASCAL 
  804. WndProc(HWND hwnd, WORD message, WORD wParam, LONG lParam)
  805. {    gx_device_win *wdev;
  806.     HDC hdc, mem;
  807.     PAINTSTRUCT ps;
  808.     RECT rect;
  809.     HBITMAP bitmap;
  810.     HPALETTE oldpalette;
  811.     int nVscrollInc, nHscrollInc;
  812.  
  813.     /* Search the list of active Windows devices */
  814.     /* to find the one owning this window. */
  815.     for ( wdev = (gx_device_win *)gdev_win_open_list;
  816.           wdev != 0; wdev = wdev->next_wdev
  817.         )
  818.       if ( wdev->hwndimg == hwnd ) break;
  819.     if ( wdev == 0 ) goto not_ours;        /* can this happen??? */
  820.  
  821.     switch(message) {
  822.         case WM_SYSCOMMAND:
  823.             switch(wParam) {
  824.                 case M_COPY_CLIP:
  825.                     /* make some where to put it and copy */
  826.                     bitmap = CreateCompatibleBitmap(wdev->hdcbit, wdev->width,
  827.                         wdev->height);
  828.                     if (bitmap) {
  829.                         /* there is enough memory and the bitmaps OK */
  830.                         mem = CreateCompatibleDC(wdev->hdcbit);
  831.                         SelectObject(mem, bitmap);
  832.                         BitBlt(mem,0,0,wdev->width,
  833.                             wdev->height, wdev->hdcbit, 0, 0, SRCCOPY);
  834.                         DeleteDC(mem);
  835.                     }
  836.                     else {
  837.                         puts("\nInsufficient Memory to Copy Clipboard");
  838.                         MessageBeep(0);
  839.                     }
  840.  
  841.                     OpenClipboard(hwnd);
  842.                     EmptyClipboard();
  843.                     SetClipboardData(CF_BITMAP, bitmap);
  844.                     CloseClipboard();
  845.  
  846.                     return 0;
  847.             }
  848.             break;
  849.         case WM_SIZE:
  850.             wdev->cyClient = HIWORD(lParam);
  851.             wdev->cxClient = LOWORD(lParam);
  852.  
  853.             wdev->cyAdjust = max(32,min(wdev->height, wdev->cyClient)) - wdev->cyClient;
  854.             wdev->cyClient += wdev->cyAdjust;
  855.  
  856.             wdev->nVscrollMax = max(0, wdev->height - wdev->cyClient);
  857.             wdev->nVscrollPos = min(wdev->nVscrollPos, wdev->nVscrollMax);
  858.  
  859.             SetScrollRange(hwnd, SB_VERT, 0, wdev->nVscrollMax, FALSE);
  860.             SetScrollPos(hwnd, SB_VERT, wdev->nVscrollPos, TRUE);
  861.  
  862.             wdev->cxAdjust = max(32,min(wdev->width,  wdev->cxClient)) - wdev->cxClient;
  863.             wdev->cxClient += wdev->cxAdjust;
  864.  
  865.             wdev->nHscrollMax = max(0, wdev->width - wdev->cxClient);
  866.             wdev->nHscrollPos = min(wdev->nHscrollPos, wdev->nHscrollMax);
  867.  
  868.             SetScrollRange(hwnd, SB_HORZ, 0, wdev->nHscrollMax, FALSE);
  869.             SetScrollPos(hwnd, SB_HORZ, wdev->nHscrollPos, TRUE);
  870.  
  871.             if ((wParam==SIZENORMAL) && (wdev->cxAdjust!=0 || wdev->cyAdjust!=0)) {
  872.                 GetWindowRect(hwnd,&rect);
  873.                 MoveWindow(hwnd,rect.left,rect.top,
  874.                 rect.right-rect.left+wdev->cxAdjust,
  875.                 rect.bottom-rect.top+wdev->cyAdjust, TRUE);
  876.                 wdev->cxAdjust = wdev->cyAdjust = 0;
  877.             }
  878.             return(0);
  879.         case WM_VSCROLL:
  880.             switch(wParam) {
  881.                 case SB_TOP:
  882.                     nVscrollInc = -wdev->nVscrollPos;
  883.                     break;
  884.                 case SB_BOTTOM:
  885.                     nVscrollInc = wdev->nVscrollMax - wdev->nVscrollPos;
  886.                     break;
  887.                 case SB_LINEUP:
  888.                     nVscrollInc = -wdev->cyClient/16;
  889.                     break;
  890.                 case SB_LINEDOWN:
  891.                     nVscrollInc = wdev->cyClient/16;
  892.                     break;
  893.                 case SB_PAGEUP:
  894.                     nVscrollInc = min(-1,-wdev->cyClient);
  895.                     break;
  896.                 case SB_PAGEDOWN:
  897.                     nVscrollInc = max(1,wdev->cyClient);
  898.                     break;
  899.                 case SB_THUMBPOSITION:
  900.                     nVscrollInc = LOWORD(lParam) - wdev->nVscrollPos;
  901.                     break;
  902.                 default:
  903.                     nVscrollInc = 0;
  904.                 }
  905.             if (nVscrollInc = max(-wdev->nVscrollPos, 
  906.                 min(nVscrollInc, wdev->nVscrollMax - wdev->nVscrollPos))) {
  907.                 wdev->nVscrollPos += nVscrollInc;
  908.                 ScrollWindow(hwnd,0,-nVscrollInc,NULL,NULL);
  909.                 SetScrollPos(hwnd,SB_VERT,wdev->nVscrollPos,TRUE);
  910.                 UpdateWindow(hwnd);
  911.             }
  912.             return(0);
  913.         case WM_HSCROLL:
  914.             switch(wParam) {
  915.                 case SB_LINEUP:
  916.                     nHscrollInc = -wdev->cxClient/16;
  917.                     break;
  918.                 case SB_LINEDOWN:
  919.                     nHscrollInc = wdev->cyClient/16;
  920.                     break;
  921.                 case SB_PAGEUP:
  922.                     nHscrollInc = min(-1,-wdev->cxClient);
  923.                     break;
  924.                 case SB_PAGEDOWN:
  925.                     nHscrollInc = max(1,wdev->cxClient);
  926.                     break;
  927.                 case SB_THUMBPOSITION:
  928.                     nHscrollInc = LOWORD(lParam) - wdev->nHscrollPos;
  929.                     break;
  930.                 default:
  931.                     nHscrollInc = 0;
  932.                 }
  933.             if (nHscrollInc = max(-wdev->nHscrollPos, 
  934.                 min(nHscrollInc, wdev->nHscrollMax - wdev->nHscrollPos))) {
  935.                 wdev->nHscrollPos += nHscrollInc;
  936.                 ScrollWindow(hwnd,-nHscrollInc,0,NULL,NULL);
  937.                 SetScrollPos(hwnd,SB_HORZ,wdev->nHscrollPos,TRUE);
  938.                 UpdateWindow(hwnd);
  939.             }
  940.             return(0);
  941.         case WM_KEYDOWN:
  942.             switch(wParam) {
  943.                 case VK_HOME:
  944.                     SendMessage(hwnd,WM_VSCROLL,SB_TOP,0L);
  945.                     break;
  946.                 case VK_END:
  947.                     SendMessage(hwnd,WM_VSCROLL,SB_BOTTOM,0L);
  948.                     break;
  949.                 case VK_PRIOR:
  950.                     SendMessage(hwnd,WM_VSCROLL,SB_PAGEUP,0L);
  951.                     break;
  952.                 case VK_NEXT:
  953.                     SendMessage(hwnd,WM_VSCROLL,SB_PAGEDOWN,0L);
  954.                     break;
  955.                 case VK_UP:
  956.                     SendMessage(hwnd,WM_VSCROLL,SB_LINEUP,0L);
  957.                     break;
  958.                 case VK_DOWN:
  959.                     SendMessage(hwnd,WM_VSCROLL,SB_LINEDOWN,0L);
  960.                     break;
  961.                 case VK_LEFT:
  962.                     SendMessage(hwnd,WM_HSCROLL,SB_PAGEUP,0L);
  963.                     break;
  964.                 case VK_RIGHT:
  965.                     SendMessage(hwnd,WM_HSCROLL,SB_PAGEDOWN,0L);
  966.                     break;
  967.             }
  968.             return(0);
  969.         case WM_PAINT:
  970.             {
  971.             int sx,sy,wx,wy,dx,dy;
  972.             hdc = BeginPaint(hwnd, &ps);
  973.             oldpalette = SelectPalette(hdc,wdev->himgpalette,NULL);
  974.             RealizePalette(hdc);
  975.             SetMapMode(hdc, MM_TEXT);
  976.             SetBkMode(hdc,OPAQUE);
  977.             GetClientRect(hwnd, &rect);
  978.             SetViewportExt(hdc, rect.right, rect.bottom);
  979.             dx = rect.left;    /* destination */
  980.             dy = rect.top;
  981.             wx = rect.right-rect.left; /* width */
  982.             wy = rect.bottom-rect.top;
  983.             sx = rect.left;    /* source */
  984.             sy = rect.top;
  985.             sx += wdev->nHscrollPos; /* scrollbars */
  986.             sy += wdev->nVscrollPos;    
  987.             if (sx+wx > wdev->width)
  988.                 wx = wdev->width - sx;
  989.             if (sy+wy > wdev->height)
  990.                 wy = wdev->height - sy;
  991.             BitBlt(hdc,dx,dy,wx,wy,wdev->hdcbit,sx,sy,SRCCOPY);
  992.             SelectPalette(hdc,oldpalette,NULL);
  993.             EndPaint(hwnd, &ps);
  994.             return 0;
  995.             }
  996.     }
  997.  
  998. not_ours:
  999.     return DefWindowProc((HWND)hwnd, (WORD)message, (WORD)wParam, (DWORD)lParam);
  1000. }
  1001.